package com.example.kotlin.design.pattern.proxy;
import android.content.Context;
import org.jetbrains.annotations.Nullable;
import java.util.concurrent.atomic.AtomicBoolean;


/**
 * MBB访问入口
 *
 */
public class ConnectorManager implements IConnectorManager {

    public static final boolean SUCCESS = true;
    public static final boolean FAILURE_BOOLEAN = false;

    public static final String TAG_HARMAN = "Harman-";

   // private MBBConnector mbbConnector;

    /**
     * 当前车辆，可执行灰色服务
     */
    //private Vehicle selectVehicle;
    private String selectVin;

    /**
     * mbb-sdk 正在执行鉴权登陆
     */
    private volatile boolean isAuthing;

    /**
     * mbb-sdk 鉴权是否成功
     */
    private volatile boolean isAuthSuccess;

    /**
     * 哈曼地图鉴权scope, SCOPE_HARMAN = "t21-vs_a:harman"
     */
    private static final String SCOPE_HARMAN = "t2-s_a:harman";

    /**
     * 是否正在加载车辆数据
     */
    private final AtomicBoolean isLoadingVehicleInfo = new AtomicBoolean();

    /**
     * 上一次加载权限列表的时间
     */
    private long lastRequestTime;

    /**
     * 是否正在刷新Harman AT
     */
    private volatile boolean isRefreshingHarmanToken;

    /**
     * 防盗告警第一页
     */
    public static final int THEFT_ALARM_OFFSET = 0;

    /**
     * 每页条数
     */
    public static final int PAGE_LIMIT = 10;

    /**
     * 灰色服务权限列表
     */
    //private OperationList mOperationList;


    public static ConnectorManager getInstance() {
        return SingletonHolder.INSTANCE;
    }



    private static class SingletonHolder {
        private static final ConnectorManager INSTANCE = new ConnectorManager();
    }

    private ConnectorManager() {

    }

    @Override
    public synchronized void initMbbConnector(Context context) {
//        if (mbbConnector == null) {
//            logger(getClass(), GsdkLog.TAG + " init ...");
//            mbbConnector = MBBConnectorConfigurationKt.mbbConnector(context);
//            initLogger();
//        }
    }

    @Override
    public void authenticate(String idToken, String clientName, @Nullable String vin) {

    }

    @Override
    public void clearVehicle() {

    }

    @Override
    public void revokeToken() {

    }

    @Override
    public void reloadOperationListPost(String vin) {
        System.out.println("reloadOperationListPost");
    }

    /**
     * 获取Harman鉴权的token
     */
//    @Override
//    public synchronized void refreshHarmanAccessToken(@NotNull AbsConnectorQueryCallBack<AccessToken> callBack)  {
//        if (mbbConnector == null) {
//            logger(getClass(), "MbbConnector == null, stop querying Harman AT !");
//            return;
//        }
//
//        String serviceName = ServiceEnum.QUERY_HARMAN_ACCESS_TOKEN.getServiceName();
//        callBack.setFuncName(serviceName);
//        if (isRefreshingHarmanToken) {
//            return;
//        }
//        isRefreshingHarmanToken = true;
//
//        String vin = "";
//        if (selectVehicle != null) {
//            vin = selectVehicle.getVin();
//        }
//
//        logStart(vin, serviceName);
//        mbbConnector.accessToken(
//                SCOPE_HARMAN,
//                MainThreadCompletionHandler.INSTANCE,
//                result -> {
//                    isRefreshingHarmanToken = false;
//                    MBBError mbbError = ResultKt.getErrorOrNull(result);
//                    if (mbbError != null) {
//                        callBack.onFailure(mbbError);
//                        return Unit.INSTANCE;
//                    }
//                    AuthenticationToken authenticationToken = ResultKt.getResultOrNull(result);
//                    if (authenticationToken == null) {
//                        callBack.onResponse(null);
//                    } else {
//                        callBack.onResponse(authenticationToken.getAccessToken());
//                    }
//                    return Unit.INSTANCE;
//                });
//    }
//
//    /**
//     * 初始化SDK内部的日志类
//     */
//    public synchronized void initLogger() {
//        String[] perms = {
//                Manifest.permission.READ_EXTERNAL_STORAGE,
//                Manifest.permission.WRITE_EXTERNAL_STORAGE
//        };
//        if (!EasyPermissions.hasPermissions(FrameworkApplication.getContext(), perms)) {
//            logger(getClass(), "logger has no storage permissions!");
//            return;
//        }
//        LogSink logSink = createLogSink();
//        List<LogSink> sinkList = Collections.singletonList(logSink);
//        L.setup(sinkList);
//    }
//
//    private LogSink createLogSink() {
//        return new LogSinkImpl();
//    }
//
//    /**
//     * 鉴权
//     *
//     * @param idToken
//     * @param clientName
//     * @param vin
//     */
//    @Override
//    public synchronized void authenticate(String idToken, String clientName, @Nullable String vin) {
//        String methodName = ServiceEnum.AUTHENTICATE.getServiceName();
//        if (mbbConnector == null) {
//            logger(getClass(), methodName + " stopped! mbbConnector == null");
//            return;
//        }
//
//        if (isAuthSuccess) {
//            logger(getClass(), methodName + " success! don't repeat it !");
//            return;
//        }
//
//        if (isAuthing) {
//            logger(getClass(), methodName + " is executing! Please wait...");
//            return;
//        }
//        isAuthing = true;
//
//        logStart(vin, methodName);
//        selectVehicle = null;
//        mbbConnector.authenticate(
//                idToken,
//                clientName,
//                MainThreadCompletionHandler.INSTANCE, mbbError -> {
//                    isAuthSuccess = (mbbError == null);
//                    isAuthing = false;
//                    if (!isAuthSuccess) {
//                        MbbResp mbbResp = HandleError.handle(methodName, mbbError);
//                        // 鉴权失败，发送事件
//                        EventBus.getDefault().post(new AuthEvent(false, mbbResp));
//                        return Unit.INSTANCE;
//                    }
//                    EventBus.getDefault().post(new AuthEvent(true, null));
//                    logSuccess(methodName);
//                    AccountUtil.savePersistableData(mbbConnector.getPersistableData());
//                    if (!TextUtils.isEmpty(vin)) {
//                        reloadOperationListPost(vin);
//                    }
//                    return Unit.INSTANCE;
//                });
//    }
//
//    /**
//     * 获取当前操作的默认车辆
//     *
//     * @return
//     */
//    @Override
//    @Nullable
//    public  Vehicle getSelectVehicle() {
//        return selectVehicle;
//    }
//
//    /**
//     * 隐私模式是否开启
//     * isPrivacyModeEnabled: Checks if at least one service of the Operation List is locally disabled.
//     * It will return null if the operation is not available.
//     * @return true：开启 false:关闭
//     */
//    public boolean isPrivacyModeEnabled() {
//        if (selectVehicle == null) {
//            return false;
//        }
//        final Boolean privacyModeEnabled = selectVehicle.isPrivacyModeEnabled();
//        if (privacyModeEnabled == null) {
//            return true;
//        }
//        return privacyModeEnabled;
//    }
//
//    /**
//     * 重置所有状态
//     */
//    @Override
//    public synchronized void clearVehicle() {
//        isRefreshingHarmanToken = false;
//        selectVehicle = null;
//        selectVin = null;
//        isAuthing = false;
//        isAuthSuccess = false;
//        revokeToken();
//    }
//
//    /**
//     * 移除MBB-token
//     */
//    @Override
//    public void revokeToken() {
//        if (mbbConnector == null) {
//            return;
//        }
//        String method = ServiceEnum.REVOKE_TOKEN.getServiceName();
//        mbbConnector.revokeToken(MainThreadCompletionHandler.INSTANCE, mbbError -> {
//            if (mbbError != null) {
//                logFailed(method, mbbError.getDescription());
//                return Unit.INSTANCE;
//            }
//            logSuccess(method);
//            return Unit.INSTANCE;
//        });
//    }
//
//
//    /**
//     * 使用默认车辆加载权限列表
//     */
//    @Override
//    public void reloadOperationList() {
//        if (StringUtils.isEmpty(selectVin)) {
//            logger(getClass(), "selected vin is empty, reloadOperationList has stopped !");
//            return;
//        }
//        reloadOperationList(selectVin);
//    }
//
//    /**
//     * 使用指定车辆刷新权限列表，刷新成功后不通知刷新服务
//     *
//     * @param vin
//     */
//    @Override
//    public void reloadOperationList(String vin) {
//        reloadOperationList(vin, null);
//    }
//
//    /**
//     * 刷新权限列表，成功后分发结果到外层
//     *
//     * @param vin
//     */
//    @Override
//    public void reloadOperationListPost(String vin) {
//        reloadOperationList(vin, new AbsConnectorQueryCallBack<OperationList>() {
//            @Override
//            protected void onSuccess(@NotNull OperationList operationList) {
//                mOperationList = operationList;
//                EventBus.getDefault().post(new ReloadOperationListEvent(true, operationList));
//                /*String pushToken = mbbConnector.getRegisteredPushNotificationToken();
//                logger(getClass(), "push_token = " + pushToken);*/
//            }
//
//            @Override
//            public void onDataEmpty() {
//                logger(getClass(), getFuncName() + ", response data from MBB is empty!");
//                EventBus.getDefault().post(new ReloadOperationListEvent(false));
//            }
//
//            @Override
//            public void onFailed(MbbResp mbbResp) {
//                logger(getClass(), getFuncName(), mbbResp.getDescCN());
//                EventBus.getDefault().post(new ReloadOperationListEvent(false));
//            }
//        });
//    }
//
//    /**
//     * 加载权限列表
//     *
//     * @param vin
//     * @param callBack
//     */
//    @Override
//    public synchronized void reloadOperationList(String vin, @Nullable AbsConnectorQueryCallBack<OperationList> callBack) {
//        String methodName = ServiceEnum.RELOAD_OPERATION_LIST.getServiceName();
//        if (TextUtils.isEmpty(vin)) {
//            logger(getClass(), methodName + " stopped! vin is empty!");
//            return;
//        }
//        if (callBack != null) {
//            callBack.setFuncName(methodName);
//        }
//        if (isLoadingVehicleInfo.get()) {
//            // 如果正在加载权限列表，停止
//            return;
//        }
//        isLoadingVehicleInfo.set(true);
//        logStart(vin, methodName);
//        this.selectVin = null;
//        Vehicle vehicle = new Vehicle(mbbConnector, vin);
//        LoadableKt.reloadAsync(vehicle.getOperationList(), new Function1<Result<OperationList, MBBError>, Unit>() {
//            @Override
//            public Unit invoke(Result<OperationList, MBBError> result) {
//                isLoadingVehicleInfo.set(false);
//                if (result instanceof Success) {
//                    logger(getClass(), "vehicle.isPrivacyModeEnabled() = " + vehicle.isPrivacyModeEnabled());
//                    selectVehicle = vehicle;
//                    selectVin = vehicle.getVin();
//
//                    if (callBack == null) {
//                        logger(getClass(), "reloadOperationList(), second params 'AbsQueryCallBack' is null !");
//                        return Unit.INSTANCE;
//                    }
//                    OperationList operationList = ResultKt.getResultOrNull(result);
//                    mOperationList = operationList;
//                    callBack.onResponse(operationList);
//                } else if (result instanceof Failure) {
//                    selectVehicle = null;
//                    selectVin = null;
//
//                    MBBError mbbError = ((Failure<OperationList, MBBError>) result).getError();
//                    if (callBack == null) {
//                        logFailed(methodName, "callBack is null !");
//                    } else {
//                        MbbResp mbbResp = callBack.onFailure(mbbError);
//                        String tips = mbbResp == null ? FrameworkApplication.getContext().getString(R.string.mbb_http_error_server) :
//                                mbbResp.getDescCN();
//                        GsdkLog.logger(getClass(), methodName + "failed, tips = " + tips);
//                        /*XTaskDispatcherExecutor.getInstance().postToMainThread(new Runnable() {
//                            @Override
//                            public void run() {
//                                Toast.makeText(FrameworkApplication.getContext(),
//                                        methodName + ":" +  tips, Toast.LENGTH_SHORT).show();
//                            }
//                        });*/
//                    }
//                }
//                return Unit.INSTANCE;
//            }
//        });
//    }
//
//    @Override
//    public void queryVsr(boolean isRequestCurrent, AbsConnectorCallBack<StatusReport> vsrCallBack) {
//        if (isRequestCurrent) {
//            queryCurrentVsr(vsrCallBack);
//        } else {
//            queryStoredVsr(vsrCallBack);
//        }
//    }
//
//    /**
//     * 查询存储在服务器上的车辆状态
//     *
//     * @param vsrCallBack
//     */
//    @Override
//    public void queryStoredVsr(@Nullable AbsConnectorCallBack<StatusReport> vsrCallBack) {
//        queryVehicleStatusReport(false, false, vsrCallBack, null);
//    }
//
//    /**
//     * 查询车辆实时数据
//     *
//     * @param vsrCallBack
//     */
//    @Override
//    public void queryCurrentVsr(@Nullable AbsConnectorCallBack<StatusReport> vsrCallBack) {
//        queryVehicleStatusReport(true, false, vsrCallBack, null);
//    }
//
//    /**
//     * 查询车辆实时数据和告警
//     *
//     * @param vsrCallBack     不为空时，可返回车辆实时数据；
//     * @param warningCallBack
//     */
//    @Override
//    public void queryVsrAndWarnings(@Nullable AbsConnectorCallBack<StatusReport> vsrCallBack, @Nullable AbsConnectorCallBack<InstrumentClusterReport> warningCallBack) {
//        queryVehicleStatusReport(true, true, vsrCallBack, warningCallBack);
//    }
//
//
//    /**
//     * 查询服务器上存储的RVS状态
//     *
//     * @param isRequestCurrent  请求车辆实时数据
//     * @param isRequestWarnings
//     * @param vsrCallBack
//     * @param warningCallBack
//     */
//    private void queryVehicleStatusReport(boolean isRequestCurrent, boolean isRequestWarnings, @Nullable AbsConnectorCallBack<StatusReport> vsrCallBack, @Nullable AbsConnectorCallBack<InstrumentClusterReport> warningCallBack) {
//
//        String methodName;
//        if (isRequestCurrent && isRequestWarnings) {
//            methodName = ServiceEnum.QUERY_WARNINGS.getServiceName();
//            if (vsrCallBack != null) {
//                vsrCallBack.setFuncName(methodName);
//            }
//            if (warningCallBack != null) {
//                warningCallBack.setFuncName(methodName);
//            }
//        } else if (isRequestCurrent) {
//            methodName = ServiceEnum.QUERY_CURRENT_STATUS_REPORT.getServiceName();
//            if (vsrCallBack != null) {
//                vsrCallBack.setFuncName(methodName);
//            }
//        } else {
//            methodName = ServiceEnum.QUERY_VEHICLE_STATUS.getServiceName();
//            if (vsrCallBack != null) {
//                vsrCallBack.setFuncName(methodName);
//            }
//        }
//        boolean isIntercepted = interceptor(methodName, selectVin, vsrCallBack);
//        if (isIntercepted) {
//            return;
//        }
//
//        VehicleStatusReportService vsrService = selectVehicle.getVehicleStatusReportService();
//        // 1. 添加回调监听Observer，成功后，在ReportObserver移除监听
//        /*StatusReportObserver statusReportObserver = new StatusReportObserver(methodName, vsrCallBack);
//        vsrService
//                .getReport()
//                .getLoadingStateObservers()
//                .addObserver(
//                        true,
//                        null,
//                        statusReportObserver
//                );*/
//        if (isRequestCurrent) {
//            // 2. 添加实时数据请求过程的监听，拿到actionId后请求车辆健康报告
//            /*PendingActionCoordinator.ActionObserver<VehicleStatusReportAction> actionObserver =
//                new VsrPendingActionObserver(methodName, isRequestWarnings, vsrCallBack, warningCallBack, vsrService);
//            vsrService
//                    .getPendingActionCoordinator()
//                    .getActionObservers()
//                    .addObserver(
//                            true,
//                            null,
//                            actionObserver
//                    );*/
//
//            // 3. 请求实时数据
//            vsrService
//                    .requestCurrentStatusReport(true,
//                            MainThreadCompletionHandler.INSTANCE,
//                            mbbError -> {
//                                if (mbbError != null) {
//                                    if (vsrCallBack != null) {
//                                        vsrCallBack.onFailure(mbbError);
//                                    }
//                                    return Unit.INSTANCE;
//                                }
//                                logger(getClass(), methodName + ", request has sent to mbb...");
//                                return Unit.INSTANCE;
//                            }
//                    );
//        } else {
//            LoadableKt.reloadAsync(vsrService.getReport(), result -> {
//                MBBError mbbError = ResultKt.getErrorOrNull(result);
//                if (mbbError != null) {
//                    if (vsrCallBack != null) {
//                        vsrCallBack.onFailure(mbbError);
//                    }
//                    return Unit.INSTANCE;
//                }
//                if (vsrCallBack != null) {
//                    StatusReport statusReport = ResultKt.getResultOrNull(result);
//                    vsrCallBack.onResponse(statusReport);
//                }
//                return Unit.INSTANCE;
//            });
//        }
//    }
//
//    /**
//     * 暂未使用
//     *
//     * @param isRequestWarnings
//     * @param vsrCallBack
//     * @param warningCallBack
//     * @param methodName
//     * @param vsrService
//     * @return
//     */
//    @NotNull
//    private PendingActionCoordinator.ActionObserver<VehicleStatusReportAction> initVsrPendingActionObserver(boolean isRequestWarnings, @Nullable AbsConnectorCallBack<StatusReport> vsrCallBack, @Nullable AbsConnectorCallBack<InstrumentClusterReport> warningCallBack, String methodName, VehicleStatusReportService vsrService) {
//        return new PendingActionCoordinator.ActionObserver<VehicleStatusReportAction>() {
//            @Override
//            public void onActionChanged(@NotNull VehicleStatusReportAction action, @NotNull PendingStatus pendingStatus, @Nullable MBBError mbbError) {
//
//                if (pendingStatus != PendingStatus.FINISHED) {
//                    logger(getClass(), methodName + " is waiting for querying vehicle warnings, pendingStatus = " + pendingStatus);
//                    if (pendingStatus == PendingStatus.FAILED) {
//                        releaseObserver();
//                        if (vsrCallBack != null) {
//                            logger(getClass(), methodName + " vsrCallBack.onFailure() invoke, pendingStatus = " + pendingStatus);
//                            vsrCallBack.onFailure(mbbError);
//                        }
//                    }
//                    return;
//                }
//
//                releaseObserver();
//                // 实时数据获取成功后回调
//                logger(getClass(), methodName + ", LoadableKt.getValue, query StatusReport...");
//                StatusReport statusReport = LoadableKt.getValue(vsrService.getReport());
//                if (vsrCallBack != null) {
//                    String timeStr = "";
//                    if (statusReport != null && statusReport.getStatusDate() != null) {
//                        timeStr = DateUtils.getDateToString(statusReport.getStatusDate().getTime(), "yyyy.MM.dd HH:mm");
//                    }
//                    logger(getClass(), methodName + " vsrCallBack.onResponse() invoke, pendingStatus = " + pendingStatus
//                            + ", StatusDateTime = " + timeStr
//                    );
//                    vsrCallBack.onResponse(statusReport);
//                }
//
//                if (!isRequestWarnings) {
//                    logger(getClass(), "don't query vehicle warnings, flag 'isRequestWarnings' = false");
//                    return;
//                }
//                // 4. 请求车辆健康报告
//                logger(getClass(), "start querying vehicle warnings, pendingStatus = " + pendingStatus);
//                vsrService
//                        .pickupInstrumentClusterWarnings(
//                                action.getId(),
//                                MainThreadCompletionHandler.INSTANCE,
//                                result -> {
//                                    MBBError error = ResultKt.getErrorOrNull(result);
//                                    if (error != null) {
//                                        if (warningCallBack != null) {
//                                            logger(getClass(), methodName + " warningCallBack.onFailure() invoke.");
//                                            warningCallBack.onFailure(error);
//                                        }
//                                        return Unit.INSTANCE;
//                                    }
//                                    InstrumentClusterReport resultOrNull = ResultKt.getResultOrNull(result);
//                                    if (warningCallBack != null) {
//                                        logger(getClass(), methodName + " warningCallBack.onResponse() invoke.");
//                                        warningCallBack.onResponse(resultOrNull);
//                                    }
//                                    return Unit.INSTANCE;
//                                }
//                        );
//            }
//
//            @Override
//            public void onNoActionAvailable() {
//                logger(getClass(), methodName + "'s actionObservers is not available");
//            }
//
//            public void releaseObserver() {
//                vsrService
//                        .getPendingActionCoordinator()
//                        .getActionObservers()
//                        .removeObserver(this);
//            }
//        };
//    }
//
//    /**
//     * 查询当前车辆的ASR配置信息
//     *
//     * @param vin
//     * @param callBack
//     */
//    @Override
//    public void queryAsrConfig(String vin, @NotNull AbsConnectorQueryCallBack<Configuration> callBack) {
//
//        String methodName = ServiceEnum.QUERY_ASR_CONFIG.getServiceName();
//        callBack.setFuncName(methodName);
//
//        boolean isIntercepted = interceptor(methodName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getServiceAppointmentService().getConfiguration(
//                MainThreadCompletionHandler.INSTANCE,
//                result -> {
//                    MBBError mbbError = ResultKt.getErrorOrNull(result);
//                    if (mbbError != null) {
//                        callBack.onFailure(mbbError);
//                        return Unit.INSTANCE;
//                    }
//                    Configuration configuration = ResultKt.getResultOrNull(result);
//                    callBack.onResponse(configuration);
//                    return Unit.INSTANCE;
//                }
//        );
//    }
//
//    /**
//     * 激活或禁用ASR
//     *
//     * @param vin
//     * @param toActive true-去激活；false-关闭；
//     * @param callBack
//     */
//    @Override
//    public void activateAsrOrNot(String vin, boolean toActive, @NotNull AbsConnectorCallBack<Boolean> callBack) {
//
//        String methodName = toActive ? ServiceEnum.ACTIVATE_ASR.getServiceName()
//                : ServiceEnum.DE_ACTIVATE_ASR.getServiceName();
//        callBack.setFuncName(methodName);
//
//        boolean isIntercepted = interceptor(methodName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        Function1<MBBError, Unit> asrFunction = mbbError -> {
//            if (mbbError != null) {
//                callBack.onFailure(mbbError);
//                return Unit.INSTANCE;
//            }
//            callBack.onResponse(SUCCESS);
//            return Unit.INSTANCE;
//        };
//        ServiceAppointmentService service = selectVehicle.getServiceAppointmentService();
//        if (toActive) {
//            service.activate(MainThreadCompletionHandler.INSTANCE, asrFunction);
//        } else {
//            service.deactivate(MainThreadCompletionHandler.INSTANCE, asrFunction);
//        }
//    }
//
//
//    @Override
//    public void updateAsrConfig(String vin, @NotNull String phoneNumber, @NotNull String firstName, @NotNull String lastName, @NotNull String dealerId, @NotNull AbsConnectorCallBack<Boolean> callBack) {
//        ContactInfo.Phone contactInfo = new ContactInfo.Phone(phoneNumber, null);
//        // preferredLanguageLocale maxLength value="5"
//        Customer customer = new Customer(
//                Customer.Salutation.Companion.getMr(),
//                null,
//                firstName,
//                null,
//                lastName,
//                contactInfo,
//                true,
//                Locale.CHINESE
//        );
//        // market length value="3"
//        ServicePartner servicePartner = new ServicePartner(
//                dealerId,
//                ConnectorConstants.MARKET_CHN,
//                ServicePartner.Brand.AUDI
//        );
//        Configuration config = new Configuration(customer, servicePartner);
//        ConnectorManager.getInstance().updateAsrConfig(vin, config, callBack);
//    }
//
//    /**
//     * 更新当前车辆的ASR配置信息到服务端
//     *
//     * @param config
//     * @param callBack
//     */
//    @Override
//    public void updateAsrConfig(String vin, Configuration config, @NotNull AbsConnectorCallBack<Boolean> callBack) {
//
//        String methodName = ServiceEnum.UPDATE_ASR_CONFIG.getServiceName();
//        callBack.setFuncName(methodName);
//        boolean isIntercepted = interceptor(methodName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getServiceAppointmentService().setConfiguration(
//                config,
//                MainThreadCompletionHandler.INSTANCE,
//                mbbError -> {
//                    if (mbbError != null) {
//                        callBack.onFailure(mbbError);
//                        return Unit.INSTANCE;
//                    }
//                    callBack.onResponse(SUCCESS);
//                    return Unit.INSTANCE;
//                }
//        );
//    }
//
//    /**
//     * 查询车辆位置
//     *
//     * @param vin
//     * @param callBack
//     */
//    @Override
//    public void queryVehicleLocation(String vin, @NotNull AbsConnectorQueryCallBack<CarFinderLocation> callBack) {
//
//        String methodName = ServiceEnum.QUERY_VEHICLE_LOCATION.getServiceName();
//        callBack.setFuncName(methodName);
//
//        boolean isIntercepted = interceptor(methodName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        LoadableKt.reloadAsync(selectVehicle.getCarFinderService().getReport(), result -> {
//            MBBError mbbError = ResultKt.getErrorOrNull(result);
//            if (mbbError != null) {
//                callBack.onFailure(mbbError);
//                return Unit.INSTANCE;
//            }
//            CarFinderLocation location = ResultKt.getResultOrNull(result);
//            callBack.onResponse(location);
//            return Unit.INSTANCE;
//        });
//    }
//
//    /**
//     * 防盗告警服务是否开启
//     *
//     * @param vin
//     */
//    @Override
//    public void isTheftAlarmActivate(String vin, @NotNull AbsConnectorCallBack<Boolean> callBack) {
//        String methodName = ServiceEnum.LOAD_HISTORY_ACTIVATED.getServiceName();
//        callBack.setFuncName(methodName);
//        if (selectVehicle == null) {
//            return;
//        }
//        logStart(vin, methodName);
//        selectVehicle.getTheftAlarmService().loadHistoryActivated(MainThreadCompletionHandler.INSTANCE,
//                new Function1<Result<Boolean, MBBError>, Unit>() {
//                    @Override
//                    public Unit invoke(Result<Boolean, MBBError> result) {
//                        final MBBError mbbError = ResultKt.getErrorOrNull(result);
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        callBack.onResponse(ResultKt.getResultOrNull(result));
//                        return Unit.INSTANCE;
//                    }
//                });
//    }
//
//    /**
//     * 查询防盗高告警列表
//     *
//     * @param vin
//     * @param offset   页码
//     * @param limit    每页条数
//     * @param callBack
//     */
//    @Override
//    public void queryTheftAlarmHistory(String vin, int offset, int limit, @NotNull AbsConnectorQueryCallBack<List<TheftAlarmAlert>> callBack) {
//
//        String methodName = ServiceEnum.QUERY_THEFT_ALARM_HISTORY_LIST.getServiceName();
//        callBack.setFuncName(methodName);
//        if (selectVehicle == null) {
//            return;
//        }
//        logStart(vin, methodName);
//        selectVehicle.getTheftAlarmService().loadAlertHistory(
//                offset,
//                limit,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<Result<List<TheftAlarmAlert>, MBBError>, Unit>() {
//                    @Override
//                    public Unit invoke(Result<List<TheftAlarmAlert>, MBBError> result) {
//                        MBBError mbbError = ResultKt.getErrorOrNull(result);
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        List<TheftAlarmAlert> theftAlarmAlertList = ResultKt.getResultOrNull(result);
//                        callBack.onResponse(theftAlarmAlertList);
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    /**
//     * 查询最后一个放到告警
//     *
//     * @param vin
//     * @param callBack
//     */
//    @Override
//    public void queryLastTheftAlarm(String vin, @NotNull AbsConnectorQueryCallBack<TheftAlarmAlert> callBack) {
//
//        String methodName = ServiceEnum.QUERY_LAST_THEFT_ALARM_HISTORY.getServiceName();
//        callBack.setFuncName(methodName);
//        boolean isIntercepted = interceptor(methodName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        LoadableKt.reloadAsync(selectVehicle.getTheftAlarmService().getReport(), result -> {
//            MBBError mbbError = ResultKt.getErrorOrNull(result);
//            if (mbbError != null) {
//                callBack.onFailure(mbbError);
//                return Unit.INSTANCE;
//            }
//            TheftAlarmReport theftAlarmReport = ResultKt.getResultOrNull(result);
//            if (theftAlarmReport == null) {
//                callBack.onResponse(null);
//            } else {
//                // http 404, theftAlarmReport.getAlert() == null
//                callBack.onResponse(theftAlarmReport.getAlert());
//            }
//            return Unit.INSTANCE;
//        });
//    }
//
//    /**
//     * 删除所有的TheftAlarm
//     *
//     * @param vin
//     * @param callBack
//     */
//    @Override
//    public void deleteTheftAlarmHistory(String vin, AbsConnectorCallBack<Boolean> callBack) {
//        String methodName = ServiceEnum.DELETE_THEFT_ALARM_HISTORY.getServiceName();
//        callBack.setFuncName(methodName);
//
//        boolean isIntercepted = interceptor(methodName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getTheftAlarmService().deleteAlertHistory(
//                MainThreadCompletionHandler.INSTANCE,
//                mbbError -> {
//                    if (mbbError != null) {
//                        callBack.onFailure(mbbError);
//                        return Unit.INSTANCE;
//                    }
//                    callBack.onResponse(SUCCESS);
//                    return Unit.INSTANCE;
//                }
//        );
//    }
//
//    /**
//     * 执行远程闪灯鸣笛
//     *
//     * @param duration  持续时间，单位:秒
//     * @param latitude  纬度
//     * @param longitude 经度
//     * @param spin      安全码
//     * @param type      操作类型
//     * @param callBack
//     */
//    @Override
//    public void honkFlash(String vin, int duration, double latitude, double longitude, String spin, RemoteHonkAndFlashAction.Type type, @NotNull AbsSpinCheckConnectorCallBack<Boolean> callBack) {
//
//        String methodName;
//        if (type == RemoteHonkAndFlashAction.Type.HONK) {
//            methodName = ServiceEnum.HONK.getServiceName();
//        } else if (type == RemoteHonkAndFlashAction.Type.FLASH) {
//            methodName = ServiceEnum.FLASH.getServiceName();
//        } else {
//            methodName = ServiceEnum.HONK_AND_FLASH.getServiceName();
//        }
//        callBack.setFuncName(methodName);
//
//        boolean isIntercepted = interceptor(methodName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//
//        TimeMeasurement durationTimeMeasurement = new TimeMeasurement(duration, TimeUnit.SECOND);
//        ServiceRequest request = new ServiceRequest(
//                type,
//                durationTimeMeasurement,
//                latitude,
//                longitude
//        );
//
//        RemoteHonkAndFlashService honkAndFlashService = selectVehicle.getRemoteHonkAndFlashService();
//        /*StateObservers<PendingActionCoordinator.ActionObserver<RemoteHonkAndFlashAction>> actionObservers
//                = honkAndFlashService
//                .getPendingActionCoordinator()
//                .getActionObservers();
//
//        HonkFlashPendingActionObserver honkFlashActionObserver = new HonkFlashPendingActionObserver(selectVehicle, callBack);
//        actionObservers.addObserver(
//                true,
//                null,
//                honkFlashActionObserver
//        );*/
//        honkAndFlashService.performServiceRequest(
//                request,
//                isNeedSpin(ServiceEnum.HONK_AND_FLASH) ? spin : null,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<MBBError, Unit>() {
//                    @Override
//                    public Unit invoke(MBBError mbbError) {
//                        if (mbbError == null) {
//                            logger(getClass(), methodName + ", MBB has received this action.");
//                            return Unit.INSTANCE;
//                        }
//                        if (mbbError instanceof MBBError.SecurePin) {
//                            // PIN码异常特殊处理
//                            final MbbResp mbbResp = HandleError.handle(methodName, mbbError);
//                            XTaskDispatcherExecutor.getInstance().postToMainThread(() -> {
//                                callBack.onSPinError(mbbResp, null, null);
//                            });
//                        } else {
//                            // 2.1 PIN码校验中发生错误，如Http、InvalidParameters等，
//                            // 2.2 action请求发送时异常
//                            callBack.onFailure(mbbError);
//                        }
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    /**
//     * @param serviceEnum 服务名称
//     * @return
//     */
//    @Override
//    public boolean isNeedSpin(ServiceEnum serviceEnum) {
//        if (selectVehicle == null) {
//            return false;
//        }
//        Result<Boolean, MBBError.InsufficientPermissions> securePIN = null;
//        switch (serviceEnum) {
//            case LOCK:
//            case UNLOCK:
//                final RemoteLockUnlockService remoteLockUnlockService = selectVehicle.getRemoteLockUnlockService();
//                securePIN = remoteLockUnlockService.lockRequiresSecurePIN();
//                break;
//            case FLASH:
//            case HONK_AND_FLASH:
//                final RemoteHonkAndFlashService honkAndFlashService = selectVehicle.getRemoteHonkAndFlashService();
//                securePIN = honkAndFlashService.serviceRequestRequiresSecurePIN();
//                break;
//            default:
//        }
//        if (securePIN == null) {
//            return false;
//        }
//        Boolean isSpinResult = ResultKt.getResultOrNull(securePIN);
//        return isSpinResult == null || isSpinResult;
//    }
//
//    /**
//     * 上锁/解锁，暂无引用
//     *
//     * @param toLock
//     * @param vin
//     * @param spin
//     * @param callBack
//     */
//    @Override
//    public void lock(boolean toLock, String vin, String spin, @NotNull AbsSpinCheckConnectorCallBack<Boolean> callBack) {
//
//        String methodName = toLock ? ServiceEnum.LOCK.getServiceName() : ServiceEnum.UNLOCK.getServiceName();
//        callBack.setFuncName(methodName);
//        if (selectVehicle == null) {
//            return;
//        }
//
//        logStart(vin, methodName);
//
//        // 1. 添加对执行结果的监听observer，在此得到最终结果
//        final RemoteLockUnlockService rluService = selectVehicle.getRemoteLockUnlockService();
//        StateObservers<PendingActionCoordinator.ActionObserver<LockUnlockAction>> actionObservers
//                = rluService
//                .getPendingActionCoordinator()
//                .getActionObservers();
//
//        LockUnlockPendingActionObserver observer = new LockUnlockPendingActionObserver(selectVehicle, toLock, callBack);
//        actionObservers.addObserver(true, null, observer);
//
//        // 2. 请求执行时Completion的监听
//        Function1<MBBError, Unit> rluFunction = mbbError -> {
//            actionObservers.removeObserver(observer);
//            if (mbbError == null) {
//                // Action发送成功
//                return Unit.INSTANCE;
//            }
//            if (mbbError instanceof MBBError.SecurePin) {
//                // PIN码异常特殊处理
//                MbbResp mbbResp = HandleError.handle(methodName, mbbError);
//                XTaskDispatcherExecutor.getInstance().postToMainThread(
//                        () -> callBack.onSPinError(mbbResp, null, null)
//                );
//            } else {
//                // 2.1 PIN码校验中发生错误，如Http、InvalidParameters等，
//                // 2.2 action请求发送时异常
//                callBack.onFailure(mbbError);
//            }
//            return Unit.INSTANCE;
//        };
//        // 3. 执行RLU
//        if (toLock) {
//            rluService.lock(
//                    spin,
//                    MainThreadCompletionHandler.INSTANCE,
//                    rluFunction
//            );
//            return;
//        }
//        rluService.unlock(
//                spin,
//                MainThreadCompletionHandler.INSTANCE,
//                rluFunction
//        );
//    }
//
//    @Override
//    public void queryRluHistory(String vin, @NotNull AbsConnectorQueryCallBack<List<LockUnlockVehicleAction>> callBack) {
//
//        String methodName = ServiceEnum.QUERY_RLU_HISTORY.getServiceName();
//        callBack.setFuncName(methodName);
//        if (selectVehicle == null) {
//            return;
//        }
//
//        logStart(vin, methodName);
//
//        final RemoteLockUnlockService rluService = selectVehicle.getRemoteLockUnlockService();
//
//        rluService.loadLastLockUnlockVehicleActions(MainThreadCompletionHandler.INSTANCE, result -> {
//
//            MBBError mbbError = ResultKt.getErrorOrNull(result);
//            if (mbbError != null) {
//                callBack.onFailure(mbbError);
//                return Unit.INSTANCE;
//            }
//            callBack.onResponse(ResultKt.getResultOrNull(result));
//            return Unit.INSTANCE;
//        });
//    }
//
//    /**
//     * 查询安全中心号码
//     * @param callBack
//     */
//    @Override
//    public void queryCallCenter(String vin, @NotNull AbsConnectorQueryCallBack<CallCenter> callBack) {
//
//        String methodName = ServiceEnum.QUERY_SECURE_CENTER.getServiceName();
//        callBack.setFuncName(methodName);
//
//        boolean isIntercepted = interceptor(methodName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//
//        LoadableKt.reloadAsync(selectVehicle.getRemoteVehicleTrackerService().getReport(), result -> {
//            MBBError mbbError = ResultKt.getErrorOrNull(result);
//            if (mbbError != null) {
//                callBack.onFailure(mbbError);
//                return Unit.INSTANCE;
//            }
//            CallCenter callCenter = ResultKt.getResultOrNull(result);
//            callBack.onResponse(callCenter);
//            return Unit.INSTANCE;
//        });
//    }
//
//    /**
//     * 检查服务是否开启
//     *
//     * @return true-开启；false-未启用，然后刷新列表
//     */
//    @Override
//    public boolean isAsrEnableOrRefresh() {
//        boolean isEnable = isAsrEnable();
//        if (!isEnable) {
//            reloadOperationList(selectVehicle.getVin());
//        }
//        return isEnable;
//    }
//
//    /**
//     * ASR服务是否可用
//     *
//     * @return
//     */
////    public boolean isAsrEnable() {
////        if (selectVehicle == null) {
////            return false;
////        }
////        if (mOperationList == null) {
////            return false;
////        }
////        OperationList.Service service = mOperationList.service(ServiceId.Companion.getServiceAppointment());
////        if (service == null) {
////            return false;
////        }
////        return service.getStatus() == OperationList.Service.Status.Enabled.INSTANCE;
////    }
//    @Override
//    public boolean isAsrEnable() {
//        if (selectVehicle == null) {
//            return false;
//        }
//        if (mOperationList == null) {
//            return false;
//        }
//        boolean isEnable = false;
//        final Collection<OperationList.Service> services = mOperationList.getServices();
//        for (OperationList.Service service : services) {
//            if (service.getId() == ServiceEnum.QUERY_ASR_CONFIG.getServiceId()) {
//                OperationList.Service.Status status = service.getStatus();
//                if (status instanceof OperationList.Service.Status.Enabled) {
//                    isEnable = true;
//                }
//                break;
//            }
//        }
//        return isEnable;
//    }
//
//    /**
//     * 根据服务名称，判断服务是否可用
//     *
//     * @param serviceEnum
//     * @return
//     */
//    private boolean isServiceEnable(ServiceEnum serviceEnum) {
//        if (selectVehicle == null) {
//            return false;
//        }
//        if (mOperationList == null) {
//            return false;
//        }
//
//        switch (serviceEnum) {
//            case ACTIVATE_ASR:
//            case DE_ACTIVATE_ASR:
//                return isAsrEnable();
//            default:
//        }
//
//        return false;
//    }
//
//    @Override
//    public boolean isAuthSuccess() {
//        return isAuthSuccess;
//    }
//
//    /**
//     * 获取禁用原因
//     *
//     * @return
//     */
//    @Override
//    public void getServiceDisabledReasons() { }
//
//    public String getDeviceNameCompat() {
//        String deviceName;
//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
//            deviceName = DeviceUtils.getDeviceName(FrameworkApplication.getContext());
//        } else {
//            deviceName = mbbConnector.getAuthenticationManager().getAppInformation().getName() + "-" + Build.MODEL;
//        }
//        return deviceName;
//    }
//
//    @Override
//    public MBBConnector getMbbConnector() {
//        return mbbConnector;
//    }
//
//    /**
//     * 灰色服务请求前的统一拦截判断
//     * @param methodName
//     * @param vin
//     * @param callBack
//     * @param <T>
//     * @return
//     */
//    @Override
//    public <T> boolean interceptor(String methodName, String vin, AbsCallBack<T> callBack) {
//        logStart(vin, methodName);
//        if (!isAuthSuccess){
//            //鉴权失败重新发起鉴权
//            authenticate(IDTokenInfo.getInstance().getIdToken(),
//                    ConnectorManager.getInstance().getDeviceNameCompat(),
//                    VehicleInfo.getInstance().getVinNumber());
//            return true;
//        }
//        if (isLoadingVehicleInfo.get()) {
//            logger(getClass(), methodName + " has been intercepted, cause by loading vehicle info and operation list !");
//            return true;
//        }
//        return hasVehicleIntercepted(methodName, vin, callBack);
//    }
//
//    /**
//     * @param methodName
//     * @param vin
//     * @param callBack  回调提示用户
//     * @param <T>
//     * @return true-事件被拦截；false-未被拦截.
//     */
//    private <T> boolean hasVehicleIntercepted(String methodName, String vin, AbsCallBack<T> callBack) {
//
//        if (this.selectVehicle != null) {
//            return false;
//        }
//        logger(getClass(), methodName + ", selectVehicle == null.");
//        callBack.onFailed(
//                new MbbResp(
//                        MBB_SDK_LOADING_CAR_INFO,
//                        FrameworkApplication.getContext().getString(R.string.mbb_sdk_loading_car_info)
//                )
//        );
//        //没有车辆列表，如果登陆成功且时间间隔大于5秒，则重新加载车辆数据
//        long delta = System.currentTimeMillis() - lastRequestTime;
//        if (delta > 5000 && isAuthSuccess) {
//            logger(getClass(), methodName + ", has been intercepted, cause by no vehicle! reloadOperationListPost(...), vin = " + vin);
//            lastRequestTime = System.currentTimeMillis();
//            reloadOperationListPost(vin);
//        } else {
//            logger(getClass(), methodName + ", has been intercepted, skip reloadOperationListPost(...)! ");
//        }
//        return true;
//    }
//
//    /**
//     * 默认车辆是否加载
//     * 只有当车辆的「权限列表」和「基础数据」都加载成功时，才能认为车辆加载成功
//     *
//     * @return true-已加载；false-未加载
//     */
//    @Override
//    public boolean hasDefaultVehicle() {
//        return this.selectVehicle != null;
//    }
//
//    public static void logStart(String vin, String methodName) {
//        GsdkLog.logStart(vin, methodName);
//    }
//
//    public static void logFailed(String methodName, String errorDesc) {
//        GsdkLog.logFailed(methodName, errorDesc);
//    }
//
//    public static void logSuccess(String methodName) {
//        GsdkLog.logSuccess(methodName);
//    }
//
//    public static void logger(Class<?> cls, Object... msg) {
//        GsdkLog.logger(cls, msg);
//    }
//
//    public boolean getIsLoadingVehicleInfo() {
//        return isLoadingVehicleInfo.get();
//    }
//
////    /**
////     * 在线服务是否开启
////     *
////     * @return true-在线服务打开；false-在线服务关闭
////     */
////    public boolean isServiceEnable(ServiceId serviceId) {
////        if (mOperationList == null) {
////            return false;
////        }
////
////        boolean isEnable = false;
////        final Collection<OperationList.Service> services = mOperationList.getServices();
////        for (OperationList.Service service : services) {
////            if (TextUtils.equals(service.getId().getRawValue(), serviceId.getRawValue())) {
////                OperationList.Service.Status status = service.getStatus();
////                if (status instanceof Disabled) {
////                    final List<Disabled.Reason> reasonList = ((Disabled) status).getReasons();
////                    logger(getClass(), "serviceId = " + serviceId + ", Disabled.Reason = " + reasonList);
////                } else if (status instanceof OperationList.Service.Status.Enabled) {
////                    isEnable = true;
////                }
////                break;
////            }
////        }
////        return isEnable;
////    }
//
//    /**
//     * 对应服务的隐私模式是否开启
//     *
//     * @return true-隐私模式打开；false-隐私模式关闭
//     */
//    public boolean isPrivacyModeEnabled(ServiceId serviceId) {
//        if (mOperationList == null) {
//            return false;
//        }
//        boolean isEnable = false;
//        final Collection<OperationList.Service> services = mOperationList.getServices();
//        for (OperationList.Service service : services) {
//            if (TextUtils.equals(service.getId().getRawValue(), serviceId.getRawValue())) {
//                OperationList.Service.Status status = service.getStatus();
//                if (status instanceof Disabled) {
//                    final List<Disabled.Reason> reasonList = ((Disabled) status).getReasons();
//                    if (reasonList != null && reasonList.contains(Disabled.Reason.LOCAL_VEHICLE_DISABLED)) {
//                        isEnable = true;
//                    }
//                    logger(getClass(), "isPrivacyModeEnabled = " + isEnable + ", serviceId = " + serviceId + ", Disabled.Reason = " + reasonList);
//                } else {
//                    logger(getClass(), "isPrivacyModeEnabled = false, serviceId = " + serviceId);
//                }
//                break;
//            }
//        }
//        return isEnable;
//    }
//
//    /**
//     * 查询【超速告警定义】列表，此列表是status=ACKNOWLEDGED，代表服务器已经同步到测车成功
//     * @param vin
//     * @param callBack
//     */
//    @Override
//    public void querySpeedAlertDefinitionList(String vin, @NotNull AbsQueryCallBack<SpeedAlertDefinitionList> callBack) {
//
//        final String serviceName = ServiceEnum.QUERY_SPEED_ALERT_DEFINITION_LIST.getServiceName();
//        callBack.setFuncName(serviceName);
//
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//
//        LoadableKt.reloadAsync(
//                selectVehicle.getSpeedAlertService().getReport(),
//                new Function1<Result<SpeedAlertDefinitionList, MBBError>, Unit>() {
//                    @Override
//                    public Unit invoke(Result<SpeedAlertDefinitionList, MBBError> result) {
//                        final MBBError mbbError = ResultKt.getErrorOrNull(result);
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        SpeedAlertDefinitionList list = ResultKt.getResultOrNull(result);
//                        callBack.onResponse(list);
//                        return Unit.INSTANCE;
//                    }
//                });
//    }
//
//    /**
//     * 更新【超速告警定义】列表，更新为整体列表的更新。
//     * 单个item对象更新后，需要重新构建一个list对象，然后调用此方法。
//     * @param vin
//     * @param list
//     * @param callBack  当call.onSuccess(...)回调时，需要检查参数，true-更新完成，false-更新失败。
//     *                  此回调函数不会返回更新后服务器上的新列表，当收到更新完成"true"的参数时，如需刷新列表，请调用查询列表api。
//     */
//    @Override
//    public void updateSpeedAlertDefinitionList(String vin, @NotNull List<SpeedAlertDefinition> list, @NotNull AbsCallBack<Boolean> callBack) {
//
//        final String serviceName = ServiceEnum.UPDATE_SPEED_ALERT_DEFINITION_LIST.getServiceName();
//        callBack.setFuncName(serviceName);
//
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//
//        final SpeedAlertService speedAlertService = selectVehicle.getSpeedAlertService();
//
//        /*final PendingActionCoordinator<AlertAction> pendingActionCoordinator
//                = speedAlertService.getPendingActionCoordinator();
//        pendingActionCoordinator.getActionObservers().addObserver(
//                true,
//                null,
//                new SpeedAlertPendingActionObserver(vin, speedAlertService, callBack)
//        );*/
//        speedAlertService.sendDefinitions(
//                list,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<MBBError, Unit>() {
//                    @Override
//                    public Unit invoke(MBBError mbbError) {
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        GsdkLog.logger(getClass(), serviceName + ", mbb has received the command.");
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    /**
//     * 查询已经触发的【超速告警历史】
//     * @param vin
//     * @param limit 如果传递null，则查询全部；如果传递具体数值，则查询最近的limit条数据
//     * @param callBack
//     */
//    @Override
//    public void querySpeedAlertViolationList(String vin, @Nullable Integer limit, @NotNull AbsQueryCallBack<List<SpeedAlertViolation>> callBack) {
//
//        final String serviceName = ServiceEnum.QUERY_SPEED_ALERT_VIOLATION_LIST.getServiceName();
//        callBack.setFuncName(serviceName);
//
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//
//        selectVehicle.getSpeedAlertService().getSpeedAlertViolations(
//                limit,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<Result<List<SpeedAlertViolation>, MBBError>, Unit>() {
//                    @Override
//                    public Unit invoke(Result<List<SpeedAlertViolation>, MBBError> result) {
//                        final MBBError mbbError = ResultKt.getErrorOrNull(result);
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        final List<SpeedAlertViolation> violationList = ResultKt.getResultOrNull(result);
//                        callBack.onResponse(violationList);
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    /**
//     * 删除已经触发的【超速告警历史】
//     * @param vin
//     * @param speedAlertViolation 当为null值，删除服务器上当前车辆的所有告警数据；当不为空时，删除指定数据；
//     * @param callBack
//     */
//    @Override
//    public void deleteSpeedAlertViolations(String vin, @Nullable SpeedAlertViolation speedAlertViolation, @NotNull AbsCallBack<Boolean> callBack) {
//
//        final String serviceName = ServiceEnum.DELETE_SPEED_ALERT_VIOLATIONS.getServiceName();
//        callBack.setFuncName(serviceName);
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getSpeedAlertService().deleteAlertViolations(
//                speedAlertViolation,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<MBBError, Unit>() {
//                    @Override
//                    public Unit invoke(MBBError mbbError) {
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                        }
//                        callBack.onResponse(Boolean.TRUE);
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//
//    /**
//     * 判断 OperationList 中是否存在指定的 serviceId 节点
//     * @param serviceId
//     * @return
//     */
//    public boolean isServiceExist(ServiceId serviceId) {
//        if (mOperationList == null) {
//            return false;
//        }
//        return mOperationList.getServices().stream().anyMatch(new Predicate<OperationList.Service>() {
//            @Override
//            public boolean test(OperationList.Service service) {
//                return TextUtils.equals(service.getId().getRawValue(), serviceId.getRawValue());
//            }
//        });
//    }
//
//
//    /**
//     * 当前车辆是否支持RPA功能
//     * @return
//     */
//    public boolean isSupportRPA() {
//        return isServiceExist(ServiceId.Companion.getBleIdent())
//                && isServiceExist(ConnectorConstants.dda_pilopa_v1);
//    }
//
//    @Override
//    public void queryGeofencingDefinitionList(String vin, @NonNull AbsQueryCallBack<GeofencingDefinitionList> callBack) {
//
//        final String serviceName = ServiceEnum.QUERY_GEOFENCING_DEFINITION_LIST.getServiceName();
//        callBack.setFuncName(serviceName);
//
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//
//        LoadableKt.reloadAsync(selectVehicle.getGeofencingService().getReport(),
//                new Function1<Result<GeofencingDefinitionList, MBBError>, Unit>() {
//                    @Override
//                    public Unit invoke(Result<GeofencingDefinitionList, MBBError> result) {
//                        final MBBError mbbError = ResultKt.getErrorOrNull(result);
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        callBack.onResponse(ResultKt.getResultOrNull(result));
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    @Override
//    public void updateGeofencingDefinitionList(String vin, @NonNull List<GeofencingDefinition> list, @NonNull AbsCallBack<Boolean> callBack) {
//
//        final String serviceName = ServiceEnum.UPDATE_GEOFENCING_DEFINITION_LIST.getServiceName();
//        callBack.setFuncName(serviceName);
//
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getGeofencingService().sendDefinitions(
//                list,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<MBBError, Unit>() {
//                    @Override
//                    public Unit invoke(MBBError mbbError) {
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        GsdkLog.logger(getClass(), serviceName + ", mbb has received the command.");
//                        return Unit.INSTANCE;
//                    }
//                });
//    }
//
//    @Override
//    public void queryGeofencingViolationList(String vin, @Nullable Integer limit, @NonNull AbsQueryCallBack<List<GeofencingViolation>> callBack) {
//        final String serviceName = ServiceEnum.QUERY_SPEED_ALERT_VIOLATION_LIST.getServiceName();
//        callBack.setFuncName(serviceName);
//
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getGeofencingService().getGeofencingViolations(
//                limit,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<Result<List<GeofencingViolation>, MBBError>, Unit>() {
//                    @Override
//                    public Unit invoke(Result<List<GeofencingViolation>, MBBError> result) {
//                        final MBBError mbbError = ResultKt.getErrorOrNull(result);
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        callBack.onResponse(ResultKt.getResultOrNull(result));
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    @Override
//    public void deleteGeofencingAlertViolations(String vin, @Nullable GeofencingViolation geofencingViolation, @NonNull AbsCallBack<Boolean> callBack) {
//
//        final String serviceName = ServiceEnum.DELETE_GEOFENCING_ALERT_VIOLATIONS.getServiceName();
//        callBack.setFuncName(serviceName);
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//
//        selectVehicle.getGeofencingService().deleteAlertViolations(
//                geofencingViolation,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<MBBError, Unit>() {
//                    @Override
//                    public Unit invoke(MBBError mbbError) {
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                        }
//                        callBack.onResponse(Boolean.TRUE);
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    /**
//     * 查询泊车告警定义
//     * @param vin
//     * @param callBack
//     */
//    @Override
//    public void queryValetAlertDefinition(String vin, @NonNull AbsQueryCallBack<ValetAlertDefinition> callBack) {
//
//        final String serviceName = ServiceEnum.QUERY_VALET_ALERT_DEFINITION.getServiceName();
//        callBack.setFuncName(serviceName);
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        LoadableKt.reloadAsync(
//                selectVehicle.getValetAlertService().getReport(),
//                new Function1<Result<ValetAlertDefinition, MBBError>, Unit>() {
//                    @Override
//                    public Unit invoke(Result<ValetAlertDefinition, MBBError> result) {
//                        final MBBError mbbError = ResultKt.getErrorOrNull(result);
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        callBack.onResponse(ResultKt.getResultOrNull(result));
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    /**
//     * 使用 ValetAlertPendingActionObserver 监听
//     * @param vin
//     * @param valetAlertDefinition
//     * @param callBack
//     */
//    @Override
//    public void updateValetAlertDefinition(String vin, ValetAlertDefinition valetAlertDefinition, @NonNull AbsQueryCallBack<Boolean> callBack) {
//        final String serviceName = ServiceEnum.UPDATE_VALET_ALERT_DEFINITION.getServiceName();
//        callBack.setFuncName(serviceName);
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getValetAlertService().setDefinition(
//                valetAlertDefinition,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<MBBError, Unit>() {
//                    @Override
//                    public Unit invoke(MBBError mbbError) {
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        GsdkLog.logger(getClass(), serviceName + ", mbb has received the command.");
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    /**
//     * 需要测试，是否需要监听，使用 ValetAlertPendingActionObserver 监听
//     * Deletes the active Valet Alert Definition in the ValetAlert Business Service.
//     * This only works for definitions with status AlertAction.State.ACKNOWLEDGED.
//     * @param vin
//     * @param callBack
//     */
//    @Override
//    public void deleteValetAlertDefinition(String vin, @NonNull AbsQueryCallBack<Boolean> callBack) {
//
//        final String serviceName = ServiceEnum.DELETE_VALET_ALERT_DEFINITION.getServiceName();
//        callBack.setFuncName(serviceName);
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getValetAlertService().deleteDefinition(
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<MBBError, Unit>() {
//                    @Override
//                    public Unit invoke(MBBError mbbError) {
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        GsdkLog.logger(getClass(), serviceName + ", mbb has received the command.");
//                        callBack.onResponse(ConnectorManager.SUCCESS);
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    @Override
//    public void queryValetAlertViolationList(String vin, @Nullable Integer limit, @NonNull AbsQueryCallBack<List<ValetAlertViolation>> callBack) {
//        final String serviceName = ServiceEnum.QUERY_VALET_ALERT_VIOLATION_LIST.getServiceName();
//        callBack.setFuncName(serviceName);
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getValetAlertService().getValetAlertViolations(
//                limit,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<Result<List<ValetAlertViolation>, MBBError>, Unit>() {
//                    @Override
//                    public Unit invoke(Result<List<ValetAlertViolation>, MBBError> result) {
//                        final MBBError mbbError = ResultKt.getErrorOrNull(result);
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        callBack.onResponse(ResultKt.getResultOrNull(result));
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
//
//    /**
//     * 删除指定的ValetAlertViolation，
//     * @param vin
//     * @param valetAlertViolation   Deletes the violation or all violations in the ValetAlert Business Service if violation is null.
//     * @param callBack
//     */
//    @Override
//    public void deleteAlertViolation(String vin, @Nullable ValetAlertViolation valetAlertViolation, @NonNull AbsQueryCallBack<Boolean> callBack) {
//        final String serviceName = ServiceEnum.DELETE_ALERT_VIOLATION.getServiceName();
//        callBack.setFuncName(serviceName);
//        boolean isIntercepted = interceptor(serviceName, vin, callBack);
//        if (isIntercepted) {
//            return;
//        }
//        selectVehicle.getValetAlertService().deleteAlertViolations(
//                valetAlertViolation,
//                MainThreadCompletionHandler.INSTANCE,
//                new Function1<MBBError, Unit>() {
//                    @Override
//                    public Unit invoke(MBBError mbbError) {
//                        if (mbbError != null) {
//                            callBack.onFailure(mbbError);
//                            return Unit.INSTANCE;
//                        }
//                        callBack.onResponse(SUCCESS);
//                        return Unit.INSTANCE;
//                    }
//                }
//        );
//    }
    @Override
    public void reloadOperationList() {

    }

    @Override
    public void reloadOperationList(String vin) {

    }
}
